En este tercer vídeo vamos a mostrar cómo editar un nodo y vamos a tomar el bloque inject
que hemos venido utilizando en toda la serie de vídeos.
En primer lugar es interesante reproducir una vez más el ejemplo que mostramos en
el vídeo anterior, recordar que recibíamos un valor de milisegundos en nuestro bloque
cuando hacíamos un pulso con el ratón sobre el bloque inject y esto responde a una estructura
parecida a la de un pulsador.
Por esa razón he importado este flow que es parte de un flow que vais a encontrar
en las prácticas donde hemos renombrado bloques inject como los pulsadores marcha
y paro y en lugar de leer ese valor de milisegundos como en el caso del flow que
hemos construido pues utilizamos ese pulso que significa que le hemos dado un pulso
al pulsador marcha para hacer una modificación a las variables de marcha y paro que son
boleanas de true o false cuando le hemos dado al pulsador que en cada caso queramos.
En este caso, repito, ignoramos el valor de los milisegundos porque lo que nos
interesa es tener en cuenta cuándo se ha hecho clic sobre el pulsador que
es simulado.
Bien, lo desactivamos el flow para que no entorpezca y volvemos al flow de
interés.
Es interesante, por tanto, tener en cuenta que en la mayoría de
aplicaciones es posible que queramos leer o escribir un dato, leer un dato
que nos manda una centralita, un cálculo, un sensor y queramos escribir un
dato en una base de datos o mandarle a un actuador que tiene que hacer y
eso se va a ejecutar o debería ejecutarse de forma periódica acorde
con el periodo de muestreo que tiene cada cada elemento, el sensor por un
lado y el actuador por el otro.
Node-RED permite configurar los bloques inject de esa forma y lo vamos
a ver accediendo a la configuración del bloque haciendo doble clic sobre
él.
En primer lugar nos vamos a centrar en esta opción de configuración, aquí
solamente podríamos cambiar el nombre y esta parte de momento no la
vamos a tener en cuenta.
Nos vamos a centrar primero en esta cajita que podemos marcar que nos
marca inject once y nos da después de un periodo de tiempo concreto.
Esto implica que cuando nosotros ejecutemos, compilemos y ejecutemos
el flow, habrá un pulso después de 0,1 segundos de una décima de
segundos sin que nosotros tengamos que hacerlo automáticamente.
Lo podemos probar.
Vemos que hemos recibido un mensaje, antes lo teníamos completamente
vacío y hemos recibido sólo un mensaje una décima de segundo más
tarde que hemos compilado el programa.
Pero lo que nos interesaría es que después de ese primer pulso que
vemos que se indica con un uno aquí arriba de timestamp como de
superíndice que hacemos solamente una vez esa acción, querríamos
que se repitiera en un intervalo.
Vemos que podemos incluso acotar ese intervalo en un espacio de
tiempo o hacer que sólo se ejecute en un específico tiempo
concreto.
Vamos a nosotros elegir un intervalo y le vamos a pedir que
sea cada segundo.
Es decir, lo que debería pasar ahora es que cuando ejecutemos
compilemos ejecutemos el flow, se ejecute una vez 0,1 segundos
más tarde de que nosotros hayamos compilado y luego se repita
cada segundo ese valor, recibir el valor del injeit,
como si cada segundo nosotros estuviéramos clicando,
haciendo clic sobre la cajita azul.
Vamos a decirle que sí, borramos los datos antes que hemos
cogido y compilamos.
Veis que cada segundo lo podemos verificar con el tiempo en
el que se recibe que nos lo indica.
El mensaje 1350, 1351, 1352, por tanto validamos que estamos
recibiendo un dato cada segundo y vemos que podemos movernos
por la barra y recuperar los datos primeros que hemos recibido.
Lo podemos incluso vaciar a tiempo real y nos volverá a escribir
los últimos datos que ahora está recibiendo.
Y querría también contaros que si observáis el valor de
milisegundos que recibimos no es siempre las mismas tres
últimas cifras, que es lo que debería pasar si estuviéramos
muestreando cada segundo con precisión,
con muchísima precisión.
Eso sucede porque recordar que estamos ejecutando todo este
programa sobre la máquina virtual,
que puede estar ejecutando otras tareas a la vez y hay un
mínimo lack, hay un mínimo tiempo de respuesta cuando el
programa, nuestro programa gráfico,
hace la petición de cuántos milisegundos han pasado ahora
desde esa fecha indicada y cuando recibe esa respuesta.
Esa diferencia es la que provoca que no estamos viendo
el mismo valor exacto en las tres últimas cifras de
milisegundos en cada iteración.